# This file was automatically generated by SWIG (http://www.swig.org).
# Version 3.0.7
#
# Do not make changes to this file unless you know what you are doing--modify
# the SWIG interface file instead.





from sys import version_info
if version_info >= (2, 6, 0):
    def swig_import_helper():
        from os.path import dirname
        import imp
        fp = None
        try:
            fp, pathname, description = imp.find_module('_ifcopenshell_wrapper', [dirname(__file__)])
        except ImportError:
            import _ifcopenshell_wrapper
            return _ifcopenshell_wrapper
        if fp is not None:
            try:
                _mod = imp.load_module('_ifcopenshell_wrapper', fp, pathname, description)
            finally:
                fp.close()
            return _mod
    _ifcopenshell_wrapper = swig_import_helper()
    del swig_import_helper
else:
    import _ifcopenshell_wrapper
del version_info
try:
    _swig_property = property
except NameError:
    pass  # Python < 2.2 doesn't have 'property'.


def _swig_setattr_nondynamic(self, class_type, name, value, static=1):
    if (name == "thisown"):
        return self.this.own(value)
    if (name == "this"):
        if type(value).__name__ == 'SwigPyObject':
            self.__dict__[name] = value
            return
    method = class_type.__swig_setmethods__.get(name, None)
    if method:
        return method(self, value)
    if (not static):
        if _newclass:
            object.__setattr__(self, name, value)
        else:
            self.__dict__[name] = value
    else:
        raise AttributeError("You cannot add attributes to %s" % self)


def _swig_setattr(self, class_type, name, value):
    return _swig_setattr_nondynamic(self, class_type, name, value, 0)


def _swig_getattr_nondynamic(self, class_type, name, static=1):
    if (name == "thisown"):
        return self.this.own()
    method = class_type.__swig_getmethods__.get(name, None)
    if method:
        return method(self)
    if (not static):
        return object.__getattr__(self, name)
    else:
        raise AttributeError(name)

def _swig_getattr(self, class_type, name):
    return _swig_getattr_nondynamic(self, class_type, name, 0)


def _swig_repr(self):
    try:
        strthis = "proxy of " + self.this.__repr__()
    except:
        strthis = ""
    return "<%s.%s; %s >" % (self.__class__.__module__, self.__class__.__name__, strthis,)

try:
    _object = object
    _newclass = 1
except AttributeError:
    class _object:
        pass
    _newclass = 0


class settings(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, settings, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, settings, name)
    __repr__ = _swig_repr
    WELD_VERTICES = _ifcopenshell_wrapper.settings_WELD_VERTICES
    USE_WORLD_COORDS = _ifcopenshell_wrapper.settings_USE_WORLD_COORDS
    CONVERT_BACK_UNITS = _ifcopenshell_wrapper.settings_CONVERT_BACK_UNITS
    USE_BREP_DATA = _ifcopenshell_wrapper.settings_USE_BREP_DATA
    SEW_SHELLS = _ifcopenshell_wrapper.settings_SEW_SHELLS
    FASTER_BOOLEANS = _ifcopenshell_wrapper.settings_FASTER_BOOLEANS
    DISABLE_OPENING_SUBTRACTIONS = _ifcopenshell_wrapper.settings_DISABLE_OPENING_SUBTRACTIONS
    DISABLE_TRIANGULATION = _ifcopenshell_wrapper.settings_DISABLE_TRIANGULATION
    APPLY_DEFAULT_MATERIALS = _ifcopenshell_wrapper.settings_APPLY_DEFAULT_MATERIALS
    INCLUDE_CURVES = _ifcopenshell_wrapper.settings_INCLUDE_CURVES
    EXCLUDE_SOLIDS_AND_SURFACES = _ifcopenshell_wrapper.settings_EXCLUDE_SOLIDS_AND_SURFACES

    def __init__(self):
        this = _ifcopenshell_wrapper.new_settings()
        try:
            self.this.append(this)
        except:
            self.this = this

    def weld_vertices(self, *args):
        return _ifcopenshell_wrapper.settings_weld_vertices(self, *args)

    def use_world_coords(self, *args):
        return _ifcopenshell_wrapper.settings_use_world_coords(self, *args)

    def convert_back_units(self, *args):
        return _ifcopenshell_wrapper.settings_convert_back_units(self, *args)

    def use_brep_data(self, *args):
        return _ifcopenshell_wrapper.settings_use_brep_data(self, *args)

    def sew_shells(self, *args):
        return _ifcopenshell_wrapper.settings_sew_shells(self, *args)

    def faster_booleans(self, *args):
        return _ifcopenshell_wrapper.settings_faster_booleans(self, *args)

    def disable_opening_subtractions(self, *args):
        return _ifcopenshell_wrapper.settings_disable_opening_subtractions(self, *args)

    def disable_triangulation(self, *args):
        return _ifcopenshell_wrapper.settings_disable_triangulation(self, *args)

    def apply_default_materials(self, *args):
        return _ifcopenshell_wrapper.settings_apply_default_materials(self, *args)

    def include_curves(self, *args):
        return _ifcopenshell_wrapper.settings_include_curves(self, *args)

    def exclude_solids_and_surfaces(self, *args):
        return _ifcopenshell_wrapper.settings_exclude_solids_and_surfaces(self, *args)

    def deflection_tolerance(self, *args):
        return _ifcopenshell_wrapper.settings_deflection_tolerance(self, *args)

    def set(self, setting, value):
        return _ifcopenshell_wrapper.settings_set(self, setting, value)

    attrs = ("convert_back_units", "deflection_tolerance", "disable_opening_subtractions", "disable_triangulation", "faster_booleans", "sew_shells", "use_brep_data", "use_world_coords", "weld_vertices")
    def __repr__(self):
    	return "%s(%s)"%(self.__class__.__name__, ",".join(tuple("%s=%r"%(a, getattr(self, a)()) for a in self.attrs)))

    __swig_destroy__ = _ifcopenshell_wrapper.delete_settings
    __del__ = lambda self: None
settings_swigregister = _ifcopenshell_wrapper.settings_swigregister
settings_swigregister(settings)

class ElementSettings(settings):
    __swig_setmethods__ = {}
    for _s in [settings]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, ElementSettings, name, value)
    __swig_getmethods__ = {}
    for _s in [settings]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, ElementSettings, name)
    __repr__ = _swig_repr

    def __init__(self, settings, unit_magnitude, element_type):
        this = _ifcopenshell_wrapper.new_ElementSettings(settings, unit_magnitude, element_type)
        try:
            self.this.append(this)
        except:
            self.this = this

    def unit_magnitude(self):
        return _ifcopenshell_wrapper.ElementSettings_unit_magnitude(self)

    def element_type(self):
        return _ifcopenshell_wrapper.ElementSettings_element_type(self)
    __swig_destroy__ = _ifcopenshell_wrapper.delete_ElementSettings
    __del__ = lambda self: None
ElementSettings_swigregister = _ifcopenshell_wrapper.ElementSettings_swigregister
ElementSettings_swigregister(ElementSettings)

class Material(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, Material, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, Material, name)
    __repr__ = _swig_repr

    def __init__(self, style=None):
        this = _ifcopenshell_wrapper.new_Material(style)
        try:
            self.this.append(this)
        except:
            self.this = this

    def hasDiffuse(self):
        return _ifcopenshell_wrapper.Material_hasDiffuse(self)

    def hasSpecular(self):
        return _ifcopenshell_wrapper.Material_hasSpecular(self)

    def hasTransparency(self):
        return _ifcopenshell_wrapper.Material_hasTransparency(self)

    def hasSpecularity(self):
        return _ifcopenshell_wrapper.Material_hasSpecularity(self)

    def diffuse(self):
        return _ifcopenshell_wrapper.Material_diffuse(self)

    def specular(self):
        return _ifcopenshell_wrapper.Material_specular(self)

    def transparency(self):
        return _ifcopenshell_wrapper.Material_transparency(self)

    def specularity(self):
        return _ifcopenshell_wrapper.Material_specularity(self)

    def name(self):
        return _ifcopenshell_wrapper.Material_name(self)

    def __eq__(self, other):
        return _ifcopenshell_wrapper.Material___eq__(self, other)

    if _newclass:
    # Hide the getters with read-only property implementations
    	has_diffuse = property(hasDiffuse)
    	has_specular = property(hasSpecular)
    	has_transparency = property(hasTransparency)
    	has_specularity = property(hasSpecularity)
    	diffuse = property(diffuse)
    	specular = property(specular)
    	transparency = property(transparency)
    	specularity = property(specularity)
    	name = property(name)

    __swig_destroy__ = _ifcopenshell_wrapper.delete_Material
    __del__ = lambda self: None
Material_swigregister = _ifcopenshell_wrapper.Material_swigregister
Material_swigregister(Material)

class Representation(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, Representation, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, Representation, name)
    __repr__ = _swig_repr

    def __init__(self, settings):
        this = _ifcopenshell_wrapper.new_Representation(settings)
        try:
            self.this.append(this)
        except:
            self.this = this

    def settings(self):
        return _ifcopenshell_wrapper.Representation_settings(self)
    __swig_destroy__ = _ifcopenshell_wrapper.delete_Representation
    __del__ = lambda self: None
Representation_swigregister = _ifcopenshell_wrapper.Representation_swigregister
Representation_swigregister(Representation)

class BRep(Representation):
    __swig_setmethods__ = {}
    for _s in [Representation]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, BRep, name, value)
    __swig_getmethods__ = {}
    for _s in [Representation]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, BRep, name)
    __repr__ = _swig_repr

    def __init__(self, settings, id, shapes):
        this = _ifcopenshell_wrapper.new_BRep(settings, id, shapes)
        try:
            self.this.append(this)
        except:
            self.this = this
    __swig_destroy__ = _ifcopenshell_wrapper.delete_BRep
    __del__ = lambda self: None

    def begin(self):
        return _ifcopenshell_wrapper.BRep_begin(self)

    def end(self):
        return _ifcopenshell_wrapper.BRep_end(self)

    def shapes(self):
        return _ifcopenshell_wrapper.BRep_shapes(self)

    def getId(self):
        return _ifcopenshell_wrapper.BRep_getId(self)
BRep_swigregister = _ifcopenshell_wrapper.BRep_swigregister
BRep_swigregister(BRep)

class Serialization(Representation):
    __swig_setmethods__ = {}
    for _s in [Representation]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, Serialization, name, value)
    __swig_getmethods__ = {}
    for _s in [Representation]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, Serialization, name)
    __repr__ = _swig_repr

    def id(self):
        return _ifcopenshell_wrapper.Serialization_id(self)

    def brep_data(self):
        return _ifcopenshell_wrapper.Serialization_brep_data(self)

    def __init__(self, brep):
        this = _ifcopenshell_wrapper.new_Serialization(brep)
        try:
            self.this.append(this)
        except:
            self.this = this
    __swig_destroy__ = _ifcopenshell_wrapper.delete_Serialization
    __del__ = lambda self: None

    if _newclass:
    # Hide the getters with read-only property implementations
    	id = property(id)
    	brep_data = property(brep_data)

Serialization_swigregister = _ifcopenshell_wrapper.Serialization_swigregister
Serialization_swigregister(Serialization)


def create_shape(settings, instance, representation=None):
    return _ifcopenshell_wrapper.create_shape(settings, instance, representation)
create_shape = _ifcopenshell_wrapper.create_shape
class iterator_single_precision(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, iterator_single_precision, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, iterator_single_precision, name)
    __repr__ = _swig_repr

    def initialize(self):
        return _ifcopenshell_wrapper.iterator_single_precision_initialize(self)

    def progress(self):
        return _ifcopenshell_wrapper.iterator_single_precision_progress(self)

    def getUnitName(self):
        return _ifcopenshell_wrapper.iterator_single_precision_getUnitName(self)

    def getUnitMagnitude(self):
        return _ifcopenshell_wrapper.iterator_single_precision_getUnitMagnitude(self)

    def getLog(self):
        return _ifcopenshell_wrapper.iterator_single_precision_getLog(self)

    def getFile(self):
        return _ifcopenshell_wrapper.iterator_single_precision_getFile(self)

    def includeEntities(self, entities):
        return _ifcopenshell_wrapper.iterator_single_precision_includeEntities(self, entities)

    def excludeEntities(self, entities):
        return _ifcopenshell_wrapper.iterator_single_precision_excludeEntities(self, entities)

    def next(self):
        return _ifcopenshell_wrapper.iterator_single_precision_next(self)

    def get(self):
        return _ifcopenshell_wrapper.iterator_single_precision_get(self)

    def getObject(self, id):
        return _ifcopenshell_wrapper.iterator_single_precision_getObject(self, id)

    def create(self):
        return _ifcopenshell_wrapper.iterator_single_precision_create(self)

    def __init__(self, *args):
        this = _ifcopenshell_wrapper.new_iterator_single_precision(*args)
        try:
            self.this.append(this)
        except:
            self.this = this
    __swig_destroy__ = _ifcopenshell_wrapper.delete_iterator_single_precision
    __del__ = lambda self: None
    __swig_getmethods__["mantissa_size"] = lambda x: _ifcopenshell_wrapper.iterator_single_precision_mantissa_size
    if _newclass:
        mantissa_size = staticmethod(_ifcopenshell_wrapper.iterator_single_precision_mantissa_size)
iterator_single_precision_swigregister = _ifcopenshell_wrapper.iterator_single_precision_swigregister
iterator_single_precision_swigregister(iterator_single_precision)

def iterator_single_precision_mantissa_size():
    return _ifcopenshell_wrapper.iterator_single_precision_mantissa_size()
iterator_single_precision_mantissa_size = _ifcopenshell_wrapper.iterator_single_precision_mantissa_size

class iterator_double_precision(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, iterator_double_precision, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, iterator_double_precision, name)
    __repr__ = _swig_repr

    def initialize(self):
        return _ifcopenshell_wrapper.iterator_double_precision_initialize(self)

    def progress(self):
        return _ifcopenshell_wrapper.iterator_double_precision_progress(self)

    def getUnitName(self):
        return _ifcopenshell_wrapper.iterator_double_precision_getUnitName(self)

    def getUnitMagnitude(self):
        return _ifcopenshell_wrapper.iterator_double_precision_getUnitMagnitude(self)

    def getLog(self):
        return _ifcopenshell_wrapper.iterator_double_precision_getLog(self)

    def getFile(self):
        return _ifcopenshell_wrapper.iterator_double_precision_getFile(self)

    def includeEntities(self, entities):
        return _ifcopenshell_wrapper.iterator_double_precision_includeEntities(self, entities)

    def excludeEntities(self, entities):
        return _ifcopenshell_wrapper.iterator_double_precision_excludeEntities(self, entities)

    def next(self):
        return _ifcopenshell_wrapper.iterator_double_precision_next(self)

    def get(self):
        return _ifcopenshell_wrapper.iterator_double_precision_get(self)

    def getObject(self, id):
        return _ifcopenshell_wrapper.iterator_double_precision_getObject(self, id)

    def create(self):
        return _ifcopenshell_wrapper.iterator_double_precision_create(self)

    def __init__(self, *args):
        this = _ifcopenshell_wrapper.new_iterator_double_precision(*args)
        try:
            self.this.append(this)
        except:
            self.this = this
    __swig_destroy__ = _ifcopenshell_wrapper.delete_iterator_double_precision
    __del__ = lambda self: None
    __swig_getmethods__["mantissa_size"] = lambda x: _ifcopenshell_wrapper.iterator_double_precision_mantissa_size
    if _newclass:
        mantissa_size = staticmethod(_ifcopenshell_wrapper.iterator_double_precision_mantissa_size)
iterator_double_precision_swigregister = _ifcopenshell_wrapper.iterator_double_precision_swigregister
iterator_double_precision_swigregister(iterator_double_precision)

def iterator_double_precision_mantissa_size():
    return _ifcopenshell_wrapper.iterator_double_precision_mantissa_size()
iterator_double_precision_mantissa_size = _ifcopenshell_wrapper.iterator_double_precision_mantissa_size

class element_single_precision(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, element_single_precision, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, element_single_precision, name)
    __repr__ = _swig_repr

    def id(self):
        return _ifcopenshell_wrapper.element_single_precision_id(self)

    def parent_id(self):
        return _ifcopenshell_wrapper.element_single_precision_parent_id(self)

    def name(self):
        return _ifcopenshell_wrapper.element_single_precision_name(self)

    def type(self):
        return _ifcopenshell_wrapper.element_single_precision_type(self)

    def guid(self):
        return _ifcopenshell_wrapper.element_single_precision_guid(self)

    def context(self):
        return _ifcopenshell_wrapper.element_single_precision_context(self)

    def unique_id(self):
        return _ifcopenshell_wrapper.element_single_precision_unique_id(self)

    def transformation(self):
        return _ifcopenshell_wrapper.element_single_precision_transformation(self)

    def __init__(self, settings, id, parent_id, name, type, guid, context, trsf):
        this = _ifcopenshell_wrapper.new_element_single_precision(settings, id, parent_id, name, type, guid, context, trsf)
        try:
            self.this.append(this)
        except:
            self.this = this
    __swig_destroy__ = _ifcopenshell_wrapper.delete_element_single_precision
    __del__ = lambda self: None

    if _newclass:
    # Hide the getters with read-only property implementations
    	id = property(id)
    	parent_id = property(parent_id)
    	name = property(name)
    	type = property(type)
    	guid = property(guid)
    	context = property(context)
    	unique_id = property(unique_id)
    	transformation = property(transformation)

element_single_precision_swigregister = _ifcopenshell_wrapper.element_single_precision_swigregister
element_single_precision_swigregister(element_single_precision)

class element_double_precision(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, element_double_precision, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, element_double_precision, name)
    __repr__ = _swig_repr

    def id(self):
        return _ifcopenshell_wrapper.element_double_precision_id(self)

    def parent_id(self):
        return _ifcopenshell_wrapper.element_double_precision_parent_id(self)

    def name(self):
        return _ifcopenshell_wrapper.element_double_precision_name(self)

    def type(self):
        return _ifcopenshell_wrapper.element_double_precision_type(self)

    def guid(self):
        return _ifcopenshell_wrapper.element_double_precision_guid(self)

    def context(self):
        return _ifcopenshell_wrapper.element_double_precision_context(self)

    def unique_id(self):
        return _ifcopenshell_wrapper.element_double_precision_unique_id(self)

    def transformation(self):
        return _ifcopenshell_wrapper.element_double_precision_transformation(self)

    def __init__(self, settings, id, parent_id, name, type, guid, context, trsf):
        this = _ifcopenshell_wrapper.new_element_double_precision(settings, id, parent_id, name, type, guid, context, trsf)
        try:
            self.this.append(this)
        except:
            self.this = this
    __swig_destroy__ = _ifcopenshell_wrapper.delete_element_double_precision
    __del__ = lambda self: None

    if _newclass:
    # Hide the getters with read-only property implementations
    	id = property(id)
    	parent_id = property(parent_id)
    	name = property(name)
    	type = property(type)
    	guid = property(guid)
    	context = property(context)
    	unique_id = property(unique_id)
    	transformation = property(transformation)

element_double_precision_swigregister = _ifcopenshell_wrapper.element_double_precision_swigregister
element_double_precision_swigregister(element_double_precision)

class triangulation_element_single_precision(element_single_precision):
    __swig_setmethods__ = {}
    for _s in [element_single_precision]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, triangulation_element_single_precision, name, value)
    __swig_getmethods__ = {}
    for _s in [element_single_precision]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, triangulation_element_single_precision, name)
    __repr__ = _swig_repr

    def geometry(self):
        return _ifcopenshell_wrapper.triangulation_element_single_precision_geometry(self)

    def __init__(self, shape_model):
        this = _ifcopenshell_wrapper.new_triangulation_element_single_precision(shape_model)
        try:
            self.this.append(this)
        except:
            self.this = this
    __swig_destroy__ = _ifcopenshell_wrapper.delete_triangulation_element_single_precision
    __del__ = lambda self: None

    if _newclass:
    # Hide the getters with read-only property implementations
    	geometry = property(geometry)

triangulation_element_single_precision_swigregister = _ifcopenshell_wrapper.triangulation_element_single_precision_swigregister
triangulation_element_single_precision_swigregister(triangulation_element_single_precision)

class triangulation_element_double_precision(element_double_precision):
    __swig_setmethods__ = {}
    for _s in [element_double_precision]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, triangulation_element_double_precision, name, value)
    __swig_getmethods__ = {}
    for _s in [element_double_precision]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, triangulation_element_double_precision, name)
    __repr__ = _swig_repr

    def geometry(self):
        return _ifcopenshell_wrapper.triangulation_element_double_precision_geometry(self)

    def __init__(self, shape_model):
        this = _ifcopenshell_wrapper.new_triangulation_element_double_precision(shape_model)
        try:
            self.this.append(this)
        except:
            self.this = this
    __swig_destroy__ = _ifcopenshell_wrapper.delete_triangulation_element_double_precision
    __del__ = lambda self: None

    if _newclass:
    # Hide the getters with read-only property implementations
    	geometry = property(geometry)

triangulation_element_double_precision_swigregister = _ifcopenshell_wrapper.triangulation_element_double_precision_swigregister
triangulation_element_double_precision_swigregister(triangulation_element_double_precision)

class serialized_element_single_precision(element_single_precision):
    __swig_setmethods__ = {}
    for _s in [element_single_precision]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, serialized_element_single_precision, name, value)
    __swig_getmethods__ = {}
    for _s in [element_single_precision]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, serialized_element_single_precision, name)
    __repr__ = _swig_repr

    def geometry(self):
        return _ifcopenshell_wrapper.serialized_element_single_precision_geometry(self)

    def __init__(self, shape_model):
        this = _ifcopenshell_wrapper.new_serialized_element_single_precision(shape_model)
        try:
            self.this.append(this)
        except:
            self.this = this
    __swig_destroy__ = _ifcopenshell_wrapper.delete_serialized_element_single_precision
    __del__ = lambda self: None

    if _newclass:
    # Hide the getters with read-only property implementations
    	geometry = property(geometry)

serialized_element_single_precision_swigregister = _ifcopenshell_wrapper.serialized_element_single_precision_swigregister
serialized_element_single_precision_swigregister(serialized_element_single_precision)

class serialized_element_double_precision(element_double_precision):
    __swig_setmethods__ = {}
    for _s in [element_double_precision]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, serialized_element_double_precision, name, value)
    __swig_getmethods__ = {}
    for _s in [element_double_precision]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, serialized_element_double_precision, name)
    __repr__ = _swig_repr

    def geometry(self):
        return _ifcopenshell_wrapper.serialized_element_double_precision_geometry(self)

    def __init__(self, shape_model):
        this = _ifcopenshell_wrapper.new_serialized_element_double_precision(shape_model)
        try:
            self.this.append(this)
        except:
            self.this = this
    __swig_destroy__ = _ifcopenshell_wrapper.delete_serialized_element_double_precision
    __del__ = lambda self: None

    if _newclass:
    # Hide the getters with read-only property implementations
    	geometry = property(geometry)

serialized_element_double_precision_swigregister = _ifcopenshell_wrapper.serialized_element_double_precision_swigregister
serialized_element_double_precision_swigregister(serialized_element_double_precision)

class transformation_single_precision(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, transformation_single_precision, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, transformation_single_precision, name)
    __repr__ = _swig_repr

    def __init__(self, settings, trsf):
        this = _ifcopenshell_wrapper.new_transformation_single_precision(settings, trsf)
        try:
            self.this.append(this)
        except:
            self.this = this

    def data(self):
        return _ifcopenshell_wrapper.transformation_single_precision_data(self)

    def matrix(self):
        return _ifcopenshell_wrapper.transformation_single_precision_matrix(self)

    if _newclass:
    # Hide the getters with read-only property implementations
    	matrix = property(matrix)

    __swig_destroy__ = _ifcopenshell_wrapper.delete_transformation_single_precision
    __del__ = lambda self: None
transformation_single_precision_swigregister = _ifcopenshell_wrapper.transformation_single_precision_swigregister
transformation_single_precision_swigregister(transformation_single_precision)

class transformation_double_precision(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, transformation_double_precision, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, transformation_double_precision, name)
    __repr__ = _swig_repr

    def __init__(self, settings, trsf):
        this = _ifcopenshell_wrapper.new_transformation_double_precision(settings, trsf)
        try:
            self.this.append(this)
        except:
            self.this = this

    def data(self):
        return _ifcopenshell_wrapper.transformation_double_precision_data(self)

    def matrix(self):
        return _ifcopenshell_wrapper.transformation_double_precision_matrix(self)

    if _newclass:
    # Hide the getters with read-only property implementations
    	matrix = property(matrix)

    __swig_destroy__ = _ifcopenshell_wrapper.delete_transformation_double_precision
    __del__ = lambda self: None
transformation_double_precision_swigregister = _ifcopenshell_wrapper.transformation_double_precision_swigregister
transformation_double_precision_swigregister(transformation_double_precision)

class matrix_single_precision(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, matrix_single_precision, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, matrix_single_precision, name)
    __repr__ = _swig_repr

    def __init__(self, settings, trsf):
        this = _ifcopenshell_wrapper.new_matrix_single_precision(settings, trsf)
        try:
            self.this.append(this)
        except:
            self.this = this

    def data(self):
        return _ifcopenshell_wrapper.matrix_single_precision_data(self)

    if _newclass:
    # Hide the getters with read-only property implementations
    	data = property(data)

    __swig_destroy__ = _ifcopenshell_wrapper.delete_matrix_single_precision
    __del__ = lambda self: None
matrix_single_precision_swigregister = _ifcopenshell_wrapper.matrix_single_precision_swigregister
matrix_single_precision_swigregister(matrix_single_precision)

class matrix_double_precision(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, matrix_double_precision, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, matrix_double_precision, name)
    __repr__ = _swig_repr

    def __init__(self, settings, trsf):
        this = _ifcopenshell_wrapper.new_matrix_double_precision(settings, trsf)
        try:
            self.this.append(this)
        except:
            self.this = this

    def data(self):
        return _ifcopenshell_wrapper.matrix_double_precision_data(self)

    if _newclass:
    # Hide the getters with read-only property implementations
    	data = property(data)

    __swig_destroy__ = _ifcopenshell_wrapper.delete_matrix_double_precision
    __del__ = lambda self: None
matrix_double_precision_swigregister = _ifcopenshell_wrapper.matrix_double_precision_swigregister
matrix_double_precision_swigregister(matrix_double_precision)

class triangulation_single_precision(Representation):
    __swig_setmethods__ = {}
    for _s in [Representation]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, triangulation_single_precision, name, value)
    __swig_getmethods__ = {}
    for _s in [Representation]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, triangulation_single_precision, name)
    __repr__ = _swig_repr

    def id(self):
        return _ifcopenshell_wrapper.triangulation_single_precision_id(self)

    def verts(self):
        return _ifcopenshell_wrapper.triangulation_single_precision_verts(self)

    def faces(self):
        return _ifcopenshell_wrapper.triangulation_single_precision_faces(self)

    def edges(self):
        return _ifcopenshell_wrapper.triangulation_single_precision_edges(self)

    def normals(self):
        return _ifcopenshell_wrapper.triangulation_single_precision_normals(self)

    def material_ids(self):
        return _ifcopenshell_wrapper.triangulation_single_precision_material_ids(self)

    def materials(self):
        return _ifcopenshell_wrapper.triangulation_single_precision_materials(self)

    def __init__(self, shape_model):
        this = _ifcopenshell_wrapper.new_triangulation_single_precision(shape_model)
        try:
            self.this.append(this)
        except:
            self.this = this
    __swig_destroy__ = _ifcopenshell_wrapper.delete_triangulation_single_precision
    __del__ = lambda self: None

    if _newclass:
    # Hide the getters with read-only property implementations
    	id = property(id)
    	faces = property(faces)
    	edges = property(edges)
    	material_ids = property(material_ids)
    	materials = property(materials)


    if _newclass:
    # Hide the getters with read-only property implementations
    	verts = property(verts)
    	normals = property(normals)

triangulation_single_precision_swigregister = _ifcopenshell_wrapper.triangulation_single_precision_swigregister
triangulation_single_precision_swigregister(triangulation_single_precision)

class triangulation_double_precision(Representation):
    __swig_setmethods__ = {}
    for _s in [Representation]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, triangulation_double_precision, name, value)
    __swig_getmethods__ = {}
    for _s in [Representation]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, triangulation_double_precision, name)
    __repr__ = _swig_repr

    def id(self):
        return _ifcopenshell_wrapper.triangulation_double_precision_id(self)

    def verts(self):
        return _ifcopenshell_wrapper.triangulation_double_precision_verts(self)

    def faces(self):
        return _ifcopenshell_wrapper.triangulation_double_precision_faces(self)

    def edges(self):
        return _ifcopenshell_wrapper.triangulation_double_precision_edges(self)

    def normals(self):
        return _ifcopenshell_wrapper.triangulation_double_precision_normals(self)

    def material_ids(self):
        return _ifcopenshell_wrapper.triangulation_double_precision_material_ids(self)

    def materials(self):
        return _ifcopenshell_wrapper.triangulation_double_precision_materials(self)

    def __init__(self, shape_model):
        this = _ifcopenshell_wrapper.new_triangulation_double_precision(shape_model)
        try:
            self.this.append(this)
        except:
            self.this = this
    __swig_destroy__ = _ifcopenshell_wrapper.delete_triangulation_double_precision
    __del__ = lambda self: None

    if _newclass:
    # Hide the getters with read-only property implementations
    	id = property(id)
    	faces = property(faces)
    	edges = property(edges)
    	material_ids = property(material_ids)
    	materials = property(materials)


    if _newclass:
    # Hide the getters with read-only property implementations
    	verts = property(verts)
    	normals = property(normals)

triangulation_double_precision_swigregister = _ifcopenshell_wrapper.triangulation_double_precision_swigregister
triangulation_double_precision_swigregister(triangulation_double_precision)

class IfcAbstractEntity(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, IfcAbstractEntity, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, IfcAbstractEntity, name)

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    __swig_destroy__ = _ifcopenshell_wrapper.delete_IfcAbstractEntity
    __del__ = lambda self: None
IfcAbstractEntity_swigregister = _ifcopenshell_wrapper.IfcAbstractEntity_swigregister
IfcAbstractEntity_swigregister(IfcAbstractEntity)

class IfcBaseEntity(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, IfcBaseEntity, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, IfcBaseEntity, name)

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    __swig_destroy__ = _ifcopenshell_wrapper.delete_IfcBaseEntity
    __del__ = lambda self: None
IfcBaseEntity_swigregister = _ifcopenshell_wrapper.IfcBaseEntity_swigregister
IfcBaseEntity_swigregister(IfcBaseEntity)

class HeaderEntity(IfcAbstractEntity):
    __swig_setmethods__ = {}
    for _s in [IfcAbstractEntity]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, HeaderEntity, name, value)
    __swig_getmethods__ = {}
    for _s in [IfcAbstractEntity]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, HeaderEntity, name)

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined")

    def getArgument(self, *args):
        return _ifcopenshell_wrapper.HeaderEntity_getArgument(self, *args)

    def getInverse(self, arg2, arg3):
        return _ifcopenshell_wrapper.HeaderEntity_getInverse(self, arg2, arg3)

    def datatype(self):
        return _ifcopenshell_wrapper.HeaderEntity_datatype(self)

    def __len__(self):
        return _ifcopenshell_wrapper.HeaderEntity___len__(self)

    def type(self):
        return _ifcopenshell_wrapper.HeaderEntity_type(self)

    def __repr__(self, upper=False):
        return _ifcopenshell_wrapper.HeaderEntity___repr__(self, upper)

    def id(self):
        return _ifcopenshell_wrapper.HeaderEntity_id(self)

    def isWritable(self):
        return _ifcopenshell_wrapper.HeaderEntity_isWritable(self)
HeaderEntity_swigregister = _ifcopenshell_wrapper.HeaderEntity_swigregister
HeaderEntity_swigregister(HeaderEntity)

class FileDescription(HeaderEntity):
    __swig_setmethods__ = {}
    for _s in [HeaderEntity]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, FileDescription, name, value)
    __swig_getmethods__ = {}
    for _s in [HeaderEntity]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, FileDescription, name)

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined")
    __repr__ = _swig_repr

    def description(self, *args):
        return _ifcopenshell_wrapper.FileDescription_description(self, *args)

    def implementation_level(self, *args):
        return _ifcopenshell_wrapper.FileDescription_implementation_level(self, *args)

    if _newclass:
    # Hide the getters with read-write property implementations
    	__swig_getmethods__["description"] = description
    	__swig_setmethods__["description"] = description
    	description = property(description, description)
    	__swig_getmethods__["implementation_level"] = implementation_level
    	__swig_setmethods__["implementation_level"] = implementation_level
    	implementation_level = property(implementation_level, implementation_level)

    __swig_destroy__ = _ifcopenshell_wrapper.delete_FileDescription
    __del__ = lambda self: None
FileDescription_swigregister = _ifcopenshell_wrapper.FileDescription_swigregister
FileDescription_swigregister(FileDescription)

class FileName(HeaderEntity):
    __swig_setmethods__ = {}
    for _s in [HeaderEntity]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, FileName, name, value)
    __swig_getmethods__ = {}
    for _s in [HeaderEntity]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, FileName, name)

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined")
    __repr__ = _swig_repr

    def name(self, *args):
        return _ifcopenshell_wrapper.FileName_name(self, *args)

    def time_stamp(self, *args):
        return _ifcopenshell_wrapper.FileName_time_stamp(self, *args)

    def author(self, *args):
        return _ifcopenshell_wrapper.FileName_author(self, *args)

    def organization(self, *args):
        return _ifcopenshell_wrapper.FileName_organization(self, *args)

    def preprocessor_version(self, *args):
        return _ifcopenshell_wrapper.FileName_preprocessor_version(self, *args)

    def originating_system(self, *args):
        return _ifcopenshell_wrapper.FileName_originating_system(self, *args)

    def authorization(self, *args):
        return _ifcopenshell_wrapper.FileName_authorization(self, *args)

    if _newclass:
    # Hide the getters with read-write property implementations
    	__swig_getmethods__["name"] = name
    	__swig_setmethods__["name"] = name
    	name = property(name, name)
    	__swig_getmethods__["time_stamp"] = time_stamp
    	__swig_setmethods__["time_stamp"] = time_stamp
    	time_stamp = property(time_stamp, time_stamp)
    	__swig_getmethods__["author"] = author
    	__swig_setmethods__["author"] = author
    	author = property(author, author)
    	__swig_getmethods__["organization"] = organization
    	__swig_setmethods__["organization"] = organization
    	organization = property(organization, organization)
    	__swig_getmethods__["preprocessor_version"] = preprocessor_version
    	__swig_setmethods__["preprocessor_version"] = preprocessor_version
    	preprocessor_version = property(preprocessor_version, preprocessor_version)
    	__swig_getmethods__["originating_system"] = originating_system
    	__swig_setmethods__["originating_system"] = originating_system
    	originating_system = property(originating_system, originating_system)
    	__swig_getmethods__["authorization"] = authorization
    	__swig_setmethods__["authorization"] = authorization
    	authorization = property(authorization, authorization)

    __swig_destroy__ = _ifcopenshell_wrapper.delete_FileName
    __del__ = lambda self: None
FileName_swigregister = _ifcopenshell_wrapper.FileName_swigregister
FileName_swigregister(FileName)

class FileSchema(HeaderEntity):
    __swig_setmethods__ = {}
    for _s in [HeaderEntity]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, FileSchema, name, value)
    __swig_getmethods__ = {}
    for _s in [HeaderEntity]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, FileSchema, name)

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined")
    __repr__ = _swig_repr

    def schema_identifiers(self, *args):
        return _ifcopenshell_wrapper.FileSchema_schema_identifiers(self, *args)

    if _newclass:
    # Hide the getters with read-write property implementations
    	__swig_getmethods__["schema_identifiers"] = schema_identifiers
    	__swig_setmethods__["schema_identifiers"] = schema_identifiers
    	schema_identifiers = property(schema_identifiers, schema_identifiers)

    __swig_destroy__ = _ifcopenshell_wrapper.delete_FileSchema
    __del__ = lambda self: None
FileSchema_swigregister = _ifcopenshell_wrapper.FileSchema_swigregister
FileSchema_swigregister(FileSchema)

class IfcSpfHeader(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, IfcSpfHeader, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, IfcSpfHeader, name)
    __repr__ = _swig_repr

    def __init__(self, lexer=None):
        this = _ifcopenshell_wrapper.new_IfcSpfHeader(lexer)
        try:
            self.this.append(this)
        except:
            self.this = this
    __swig_destroy__ = _ifcopenshell_wrapper.delete_IfcSpfHeader
    __del__ = lambda self: None

    def read(self):
        return _ifcopenshell_wrapper.IfcSpfHeader_read(self)

    def tryRead(self):
        return _ifcopenshell_wrapper.IfcSpfHeader_tryRead(self)

    def write(self, os):
        return _ifcopenshell_wrapper.IfcSpfHeader_write(self, os)

    def file_description(self, *args):
        return _ifcopenshell_wrapper.IfcSpfHeader_file_description(self, *args)

    def file_name(self, *args):
        return _ifcopenshell_wrapper.IfcSpfHeader_file_name(self, *args)

    def file_schema(self, *args):
        return _ifcopenshell_wrapper.IfcSpfHeader_file_schema(self, *args)

    if _newclass:
    # Hide the getters with read-only property implementations
    	file_description = property(file_description)
    	file_name = property(file_name)
    	file_schema = property(file_schema)

IfcSpfHeader_swigregister = _ifcopenshell_wrapper.IfcSpfHeader_swigregister
IfcSpfHeader_swigregister(IfcSpfHeader)

class file(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, file, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, file, name)
    __repr__ = _swig_repr
    __swig_setmethods__["stream"] = _ifcopenshell_wrapper.file_stream_set
    __swig_getmethods__["stream"] = _ifcopenshell_wrapper.file_stream_get
    if _newclass:
        stream = _swig_property(_ifcopenshell_wrapper.file_stream_get, _ifcopenshell_wrapper.file_stream_set)

    def __init__(self, create_latebound_entities=False):
        this = _ifcopenshell_wrapper.new_file(create_latebound_entities)
        try:
            self.this.append(this)
        except:
            self.this = this
    __swig_destroy__ = _ifcopenshell_wrapper.delete_file
    __del__ = lambda self: None

    def begin(self):
        return _ifcopenshell_wrapper.file_begin(self)

    def end(self):
        return _ifcopenshell_wrapper.file_end(self)

    def by_type(self, *args):
        return _ifcopenshell_wrapper.file_by_type(self, *args)

    def entitiesByReference(self, id):
        return _ifcopenshell_wrapper.file_entitiesByReference(self, id)

    def getInverse(self, instance_id, type, attribute_index):
        return _ifcopenshell_wrapper.file_getInverse(self, instance_id, type, attribute_index)

    def FreshId(self):
        return _ifcopenshell_wrapper.file_FreshId(self)

    def addEntities(self, es):
        return _ifcopenshell_wrapper.file_addEntities(self, es)

    def header(self, *args):
        return _ifcopenshell_wrapper.file_header(self, *args)

    def createTimestamp(self):
        return _ifcopenshell_wrapper.file_createTimestamp(self)

    def create_latebound_entities(self):
        return _ifcopenshell_wrapper.file_create_latebound_entities(self)

    def getUnit(self, arg2):
        return _ifcopenshell_wrapper.file_getUnit(self, arg2)

    def by_id(self, id):
        return _ifcopenshell_wrapper.file_by_id(self, id)

    def by_guid(self, guid):
        return _ifcopenshell_wrapper.file_by_guid(self, guid)

    def add(self, e):
        return _ifcopenshell_wrapper.file_add(self, e)

    def remove(self, e):
        return _ifcopenshell_wrapper.file_remove(self, e)

    def traverse(self, e, max_level=-1):
        return _ifcopenshell_wrapper.file_traverse(self, e, max_level)

    def write(self, fn):
        return _ifcopenshell_wrapper.file_write(self, fn)

    def entity_names(self):
        return _ifcopenshell_wrapper.file_entity_names(self)

    if _newclass:
    # Hide the getters with read-only property implementations
    	header = property(header)

file_swigregister = _ifcopenshell_wrapper.file_swigregister
file_swigregister(file)

class entity_instance(IfcBaseEntity):
    __swig_setmethods__ = {}
    for _s in [IfcBaseEntity]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, entity_instance, name, value)
    __swig_getmethods__ = {}
    for _s in [IfcBaseEntity]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, entity_instance, name)

    def __init__(self, s):
        this = _ifcopenshell_wrapper.new_entity_instance(s)
        try:
            self.this.append(this)
        except:
            self.this = this

    def is_a(self, *args):
        return _ifcopenshell_wrapper.entity_instance_is_a(self, *args)

    def id(self):
        return _ifcopenshell_wrapper.entity_instance_id(self)

    def __len__(self):
        return _ifcopenshell_wrapper.entity_instance___len__(self)

    def get_argument_type(self, i):
        return _ifcopenshell_wrapper.entity_instance_get_argument_type(self, i)

    def getArgumentEntity(self, i):
        return _ifcopenshell_wrapper.entity_instance_getArgumentEntity(self, i)

    def get_argument_name(self, i):
        return _ifcopenshell_wrapper.entity_instance_get_argument_name(self, i)

    def get_argument_index(self, a):
        return _ifcopenshell_wrapper.entity_instance_get_argument_index(self, a)

    def get_argument_optionality(self, i):
        return _ifcopenshell_wrapper.entity_instance_get_argument_optionality(self, i)

    def get_inverse(self, a):
        return _ifcopenshell_wrapper.entity_instance_get_inverse(self, a)

    def get_attribute_names(self):
        return _ifcopenshell_wrapper.entity_instance_get_attribute_names(self)

    def get_inverse_attribute_names(self):
        return _ifcopenshell_wrapper.entity_instance_get_inverse_attribute_names(self)

    def setArgumentAsNull(self, i):
        return _ifcopenshell_wrapper.entity_instance_setArgumentAsNull(self, i)

    def setArgumentAsInt(self, i, v):
        return _ifcopenshell_wrapper.entity_instance_setArgumentAsInt(self, i, v)

    def setArgumentAsBool(self, i, v):
        return _ifcopenshell_wrapper.entity_instance_setArgumentAsBool(self, i, v)

    def setArgumentAsDouble(self, i, v):
        return _ifcopenshell_wrapper.entity_instance_setArgumentAsDouble(self, i, v)

    def setArgumentAsString(self, i, v):
        return _ifcopenshell_wrapper.entity_instance_setArgumentAsString(self, i, v)

    def setArgumentAsEntityInstance(self, i, v):
        return _ifcopenshell_wrapper.entity_instance_setArgumentAsEntityInstance(self, i, v)

    def setArgumentAsAggregateOfInt(self, i, v):
        return _ifcopenshell_wrapper.entity_instance_setArgumentAsAggregateOfInt(self, i, v)

    def setArgumentAsAggregateOfDouble(self, i, v):
        return _ifcopenshell_wrapper.entity_instance_setArgumentAsAggregateOfDouble(self, i, v)

    def setArgumentAsAggregateOfString(self, i, v):
        return _ifcopenshell_wrapper.entity_instance_setArgumentAsAggregateOfString(self, i, v)

    def setArgumentAsAggregateOfEntityInstance(self, i, v):
        return _ifcopenshell_wrapper.entity_instance_setArgumentAsAggregateOfEntityInstance(self, i, v)

    def setArgumentAsAggregateOfAggregateOfInt(self, i, v):
        return _ifcopenshell_wrapper.entity_instance_setArgumentAsAggregateOfAggregateOfInt(self, i, v)

    def setArgumentAsAggregateOfAggregateOfDouble(self, i, v):
        return _ifcopenshell_wrapper.entity_instance_setArgumentAsAggregateOfAggregateOfDouble(self, i, v)

    def setArgumentAsAggregateOfAggregateOfEntityInstance(self, i, v):
        return _ifcopenshell_wrapper.entity_instance_setArgumentAsAggregateOfAggregateOfEntityInstance(self, i, v)

    def __repr__(self):
        return _ifcopenshell_wrapper.entity_instance___repr__(self)

    def is_valid(self):
        return _ifcopenshell_wrapper.entity_instance_is_valid(self)

    def get_attribute_category(self, name):
        return _ifcopenshell_wrapper.entity_instance_get_attribute_category(self, name)

    def get_argument(self, *args):
        return _ifcopenshell_wrapper.entity_instance_get_argument(self, *args)
    __swig_destroy__ = _ifcopenshell_wrapper.delete_entity_instance
    __del__ = lambda self: None
entity_instance_swigregister = _ifcopenshell_wrapper.entity_instance_swigregister
entity_instance_swigregister(entity_instance)


def open(s):
    return _ifcopenshell_wrapper.open(s)
open = _ifcopenshell_wrapper.open

def schema_identifier():
    return _ifcopenshell_wrapper.schema_identifier()
schema_identifier = _ifcopenshell_wrapper.schema_identifier

def version():
    return _ifcopenshell_wrapper.version()
version = _ifcopenshell_wrapper.version
# This file is compatible with both classic and new-style classes.


